package com.work.chat.common.util;

import com.fasterxml.jackson.databind.JsonNode;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author bin.chen
 * @description 数据处理
 * @date 2022/06/10 11:21
 */
public class DataUtil {
    private static Pattern UNDERLINE_PATTERN = Pattern.compile("_([a-z])");

    /**
     * 字符串转数组json
     *
     * @param str
     */
    public static String arrayJson(String... str) {
        if (ObjectUtils.isEmpty(str)) return null;
        return JsonUtil.objectToStr(str);
    }

    /**
     * 字符串转数组json
     *
     * @param str
     */
    public static String arrayJson(String str) {
        if (ObjectUtils.isEmpty(str)) return null;
        String[] array = {str};
        return JsonUtil.objectToStr(array);
    }

    /**
     * list转数组json
     *
     * @param list
     */
    public static String arrayJson(List<String> list) {
        if (CollectionUtils.isEmpty(list)) return null;
        return JsonUtil.objectToStr(list);
    }

    /**
     * ["xxx"]转xxx
     *
     * @param arrayJson 数组json
     */
    public static String jsonStr(String arrayJson) {
        if (ObjectUtils.isEmpty(arrayJson)) return null;
        return arrayJson.replace("[", "").replace("]", "").replaceAll("\"", "");
    }


    /**
     * 根据传入的带下划线的字符串转化为驼峰格式
     *
     * @param str
     * @return
     * @author mrf
     */
    public static String underlineToHump(String str) {
        //正则匹配下划线及后一个字符，删除下划线并将匹配的字符转成大写
        Matcher matcher = UNDERLINE_PATTERN.matcher(str);
        StringBuffer sb = new StringBuffer(str);
        if (matcher.find()) {
            sb = new StringBuffer();
            //将当前匹配的子串替换成指定字符串，并且将替换后的子串及之前到上次匹配的子串之后的字符串添加到StringBuffer对象中
            //正则之前的字符和被替换的字符
            matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
            //把之后的字符串也添加到StringBuffer对象中
            matcher.appendTail(sb);
        } else {
            //去除除字母之外的前面带的下划线
            return sb.toString().replaceAll("_", "");
        }
        return underlineToHump(sb.toString());
    }

    /**
     * 生成随机数（随机下达）
     *
     * @param total 总数
     * @return
     */
    public static List<Integer> randomSendOut(long total, long randomNum) {
        Set<Integer> hashSet = new HashSet<>();
        System.out.println("随机下达数：" + randomNum);
        int randInt = 0;
        while (hashSet.size() < randomNum) {
            randInt = (int) (Math.random() * total + 1);
            hashSet.add(randInt);
        }
        return new ArrayList<>(hashSet);
    }

    /**
     * 验证日期是否在当月
     *
     * @param date
     * @return
     */
    public static boolean verifyDate(Date date) {
        if (ObjectUtils.isEmpty(date)) {
            return false;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
        return sdf.format(date).equals(sdf.format(new Date()));
    }

    /**
     * 数组字符串转List
     *
     * @param arrayStr
     * @return
     */
    public static List<String> getDataList(String arrayStr) {
        if (ObjectUtils.isEmpty(arrayStr)) return null;
        JsonNode jsonNode = JsonUtil.getJsonNode(arrayStr);
        List<String> list = new ArrayList<>();
        if (ObjectUtils.isEmpty(jsonNode)) return list;
        jsonNode.iterator().forEachRemaining(item -> list.add(item.asText()));
        return list;
    }

    /**
     * 将字符串转换成数组
     *
     * @param price
     * @return
     */
    public static BigDecimal getPrice(String price) {
        if (ObjectUtils.isEmpty(price)) {
            return BigDecimal.ZERO;
        } else {
            return new BigDecimal(price);
        }
    }

    /**
     * 预防Double.parseDouble()报空指针异常
     *
     * @param value
     * @param defaultValue
     * @return
     */
    public static double parseStringToDefaultValue(String value, double defaultValue) {
        return value == null || value.isEmpty() ? defaultValue : Double.parseDouble(value);
    }

    /**
     * 将金额转换成大写
     *
     * @param price
     * @return
     */
    public static String digitCapital(double price) {
        String[] fraction = {"角", "分"};
        String[] digit = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        String[][] unit = {{"元", "万", "亿"}, {"", "拾", "佰", "仟"}};

        String head = price < 0 ? "负" : "";
        // 如果是负数取绝对值
        price = Math.abs(price);
        String s = "";
        BigDecimal bigDecimal = new BigDecimal(Double.valueOf(price).toString());
        String nStr = bigDecimal.toString();
        // 小数部分
        String[] split = nStr.split("\\.");
        if (split.length > 1) {
            // 小数点为特殊符号，在分割时需进行转义
            String decimalStr = split[1];
            if (decimalStr.length() > 2) {
                decimalStr = decimalStr.substring(0, 2);
            }
            // 将小数部分转换为整数
            Integer integer = Integer.valueOf(decimalStr);
            String p = "";
            for (int i = 0; i < decimalStr.length() && i < fraction.length; i++) {
                p = digit[integer % 10] + fraction[decimalStr.length() - i - 1] + p;
                integer = integer / 10;
            }
            s = p.replaceAll("(零.)+", "") + s;
        }
        if (s.length() < 1) {
            s = "整";
        }
        int integerPart = (int) Math.floor(price);
        // 整数部分
        for (int i = 0; i < unit[0].length && integerPart > 0; i++) {
            String p = "";
            for (int j = 0; j < unit[1].length && price > 0; j++) {
                p = digit[integerPart % 10] + unit[1][j] + p;
                integerPart = integerPart / 10;
            }
            s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
        }
        return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
    }

}
